"
<html>
<head></head>
<body><a name=\"ZH-CN_TOPIC_0000002278863044\"></a><a name=\"ZH-CN_TOPIC_0000002278863044\"></a>
<h1>Worker简介</h1>
<div><p>Worker的主要作用是为应用程序提供一个多线程的运行环境，满足应用程序在执行过程中与宿主线程分离，在后台线程中运行脚本进行耗时操作，避免计算密集型或高延迟的任务阻塞宿主线程。具体接口信息及使用方法详情请见<a
        href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-worker\" target=\"_blank\">Worker</a>。
</p>
    <div class=\"section\" id=\"worker运作机制\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__worker%E8%BF%90%E4%BD%9C%E6%9C%BA%E5%88%B6\"></a><a
            name=\"worker%E8%BF%90%E4%BD%9C%E6%9C%BA%E5%88%B6\"></a>     <h4>Worker运作机制</h4>
        <p><strong>图1</strong> Worker运作机制示意图</p>
        <p><span><img originheight=\"605\" originwidth=\"858\"
                      src=\"https://communityfile-drcn.op.dbankcloud.cn/FileServer/getFile/cmtyPub/011/111/111/0000000000011111111.20250704161535.51614899773840687871921764112447:50001231000000:2800:74C2CB3F8033D982F83E8BAB8297ED2AB872AAAAA0D40E90641FADFCD081882E.png\"></span>
        </p>
        <p>
            创建Worker的线程称为宿主线程（不局限于主线程，Worker线程也支持创建Worker子线程）。Worker子线程（或Actor线程、工作线程）是Worker自身运行的线程。每个Worker子线程和宿主线程拥有独立的实例，包含独立执行环境、对象、代码段等。因此，启动每个Worker存在一定的内存开销，需要限制Worker子线程的数量。Worker子线程和宿主线程通过消息传递机制通信，利用序列化机制完成命令和数据的交互。</p>
    </div>
    <div class=\"section\" id=\"worker注意事项\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__worker%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a><a
            name=\"worker%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a>     <h4>Worker注意事项</h4>
        <ul>
            <li>创建Worker时，提供手动和自动两种创建方式，推荐使用自动创建方式。手动创建Worker线程目录及文件时，需同步进行相关配置，具体要求请参阅<a
                    href=\"#创建worker的注意事项\">创建Worker的注意事项</a>。
            </li>
            <li>使用Worker能力时，构造函数中传入的Worker线程文件的路径在不同版本有不同的规则，详情请参见<a
                    href=\"#文件路径注意事项\">文件路径注意事项</a>。
            </li>
            <li>Worker创建后需要手动管理生命周期。同时运行的Worker子线程数量最多为64个，并且与<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/napi#napi_create_ark_runtime\"
                    target=\"_blank\">napi_create_ark_runtime</a>创建的runtime总数不超过80。详情请参见<a
                    href=\"#生命周期注意事项\">生命周期注意事项</a>。
            </li>
            <li>
                不同线程中上下文对象是不同的，因此Worker线程只能使用线程安全的库，例如UI相关的非线程安全库不能在Worker子线程中使用。
            </li>
            <li>单次序列化传输的数据量大小限制为16MB。</li>
            <li>使用Worker模块时，API version 18及之后的版本建议在宿主线程中注册onAllErrors回调，以捕获Worker线程生命周期内的各种异常。API
                version
                18之前的版本应注册onerror回调。如果未注册onAllErrors或onerror回调，当Worker线程出现异常时会发生jscrash问题。需要注意的是，onerror接口仅能捕获onmessage回调中的同步异常，捕获异常后，Worker线程将进入销毁流程，无法继续使用。详情请参见<a
                        href=\"#onallerrors接口与onerror接口之间的行为差异\">onAllErrors接口与onerror接口之间的行为差异</a>。
            </li>
            <li>不支持跨HAP使用Worker线程文件。</li>
            <li>引用HAR/HSP中的worker前，需要先配置对HAR/HSP的依赖，详见<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/ide-har-import\"
                    target=\"_blank\">引用共享包</a>。
            </li>
            <li>不支持在Worker工作线程中使用<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-appstorage\">AppStorage</a>。
            </li>
            <li>从API version 18开始，Worker线程优先级可以在构造函数的参数<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-worker#workeroptions\"
                    target=\"_blank\">WorkerOptions</a>中进行指定。
            </li>
            <li>在Worker文件中禁止使用export语法导出任何内容，否则会导致jscrash问题。</li>
        </ul>
    </div>
    <div class=\"section\" id=\"创建worker的注意事项\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__%E5%88%9B%E5%BB%BAworker%E7%9A%84%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a><a
            name=\"%E5%88%9B%E5%BB%BAworker%E7%9A%84%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a>     <h4>
        [h2]创建Worker的注意事项</h4>
        <p>
            Worker线程文件需要放在\"{moduleName}/src/main/ets/\"目录层级之下，否则不会被打包到应用中。有手动和自动两种创建Worker线程目录及文件的方式。</p>
        <ul>
            <li><p>
                手动创建：开发者手动创建相关目录及文件，通常是在ets目录下创建一个workers文件夹，用于存放worker.ets文件，需要配置build-profile.json5的相关字段信息，确保Worker线程文件被打包到应用中。</p>
                <p>Stage模型：</p>
                <pre class=\"json\">\"buildOption\": {\n  \"sourceOption\": {\n    \"workers\": [\n      \"./src/main/ets/workers/worker.ets\"\n    ]\n  }\n}</pre>
                <p>FA模型：</p>
                <pre class=\"json\">\"buildOption\": {\n  \"sourceOption\": {\n    \"workers\": [\n      \"./src/main/ets/MainAbility/workers/worker.ets\"\n    ]\n  }\n}</pre>
            </li>
            <li><p>自动创建：DevEco Studio支持一键生成Worker，在对应的{moduleName}目录下任意位置，点击鼠标右键 &gt; New
                &gt; Worker，即可自动生成Worker的模板文件及配置信息，无需再手动在build-profile.json5中进行相关配置。</p>
            </li>
        </ul>
    </div>
    <div class=\"section\" id=\"文件路径注意事项\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__%E6%96%87%E4%BB%B6%E8%B7%AF%E5%BE%84%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a><a
            name=\"%E6%96%87%E4%BB%B6%E8%B7%AF%E5%BE%84%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a>     <h4>
        [h2]文件路径注意事项</h4>
        <p>
            当使用Worker模块具体功能时，均需先构造Worker实例对象，其构造函数与API版本相关，且构造函数需要传入Worker线程文件的路径（scriptURL）。</p>
        <pre class=\"ts\">// 导入模块\nimport { worker } from '@kit.ArkTS';\n\n// API 9及之后版本使用：\nconst worker1: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/worker.ets');\n// API 8及之前版本使用：\nconst worker2: worker.Worker = new worker.Worker('entry/ets/workers/worker.ets');</pre>
    </div>
    <p><strong>Stage模型下的文件路径规则</strong></p>
    <p>构造函数中的scriptURL要求如下：</p>
    <ul>
        <li>scriptURL的组成包含{moduleName}/ets和相对路径relativePath。</li>
        <li>relativePath是Worker线程文件相对于\"{moduleName}/src/main/ets/\"目录的相对路径。</li>
    </ul>
    <p>1） 加载Ability中Worker线程文件场景</p>
    <p>加载Ability中的worker线程文件，加载路径规则：{moduleName}/ets/{relativePath}。</p>
    <pre class=\"ts\">import { worker } from '@kit.ArkTS';\n\n// worker线程文件所在路径：\"entry/src/main/ets/workers/worker.ets\"\nconst workerStage1: worker.ThreadWorker = new worker.ThreadWorker('entry/ets/workers/worker.ets');\n\n// worker线程文件所在路径：\"testworkers/src/main/ets/ThreadFile/workers/worker.ets\"\nconst workerStage2: worker.ThreadWorker = new worker.ThreadWorker('testworkers/ets/ThreadFile/workers/worker.ets');</pre>
    <p>2） 加载<a href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/in-app-hsp\">HSP</a>中Worker线程文件场景
    </p>
    <p>加载HSP中worker线程文件，加载路径规则：{moduleName}/ets/{relativePath}。</p>
    <pre class=\"ts\">import { worker } from '@kit.ArkTS';\n\n// worker线程文件所在路径： \"hsp/src/main/ets/workers/worker.ets\"\nconst workerStage3: worker.ThreadWorker = new worker.ThreadWorker('hsp/ets/workers/worker.ets');</pre>
    <p>3） 加载<a href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/har-package\">HAR</a>中Worker线程文件场景
    </p>
    <p>加载HAR中worker线程文件存在以下两种情况：</p>
    <ul>
        <li><p>
            @标识路径加载形式：所有种类的模块加载本地HAR中的Worker线程文件，加载路径规则：@{moduleName}/ets/{relativePath}。</p>
        </li>
        <li><p>
            相对路径加载形式：本地HAR加载该包内的Worker线程文件，加载路径规则：创建Worker对象所在文件与Worker线程文件的相对路径。</p>
        </li>
    </ul>
    <div class=\"note\"><img originheight=\"38\" originwidth=\"102\"
                             src=\"https://communityfile-drcn.op.dbankcloud.cn/FileServer/getFile/cmtyPub/011/111/111/0000000000011111111.20250704161535.30493908148339631146147419580559:50001231000000:2800:0D000109B98FA0C29BAC0B0E88379A59A975C65911B23C7B858960939A59D828.png\"><span
            class=\"notetitle\"> </span>
        <div class=\"notebody\"><p>
            当开启useNormalizedOHMUrl（在工程目录中与entry同级别的应用级build-profile.json5文件中，将strictMode属性下的useNormalizedOHMUrl字段配置为true）或HAR包被打包成三方包使用时，HAR包中使用Worker仅支持通过相对路径的加载形式创建。</p>
        </div>
    </div>
    <pre class=\"ts\">import { worker } from '@kit.ArkTS';\n\n// @标识路径加载形式：\n// worker线程文件所在路径: \"har/src/main/ets/workers/worker.ets\"\nconst workerStage4: worker.ThreadWorker = new worker.ThreadWorker('@har/ets/workers/worker.ets');\n\n// 相对路径加载形式：\n// worker线程文件所在路径: \"har/src/main/ets/workers/worker.ets\"\n// 创建Worker对象的文件所在路径：\"har/src/main/ets/components/mainpage/MainPage.ets\"\nconst workerStage5: worker.ThreadWorker = new worker.ThreadWorker('../../workers/worker.ets');</pre>
    <p><strong>FA模型下的文件路径规则</strong></p>
    <p>构造函数中的scriptURL为：Worker线程文件与\"{moduleName}/src/main/ets/MainAbility\"的相对路径。</p>
    <pre class=\"ts\">import { worker } from '@kit.ArkTS';\n\n// 主要说明以下三种场景：\n\n// 场景1： Worker线程文件所在路径：\"{moduleName}/src/main/ets/MainAbility/workers/worker.ets\"\nconst workerFA1: worker.ThreadWorker = new worker.ThreadWorker('workers/worker.ets', {name:'first worker in FA model'});\n\n// 场景2： Worker线程文件所在路径：\"{moduleName}/src/main/ets/workers/worker.ets\"\nconst workerFA2: worker.ThreadWorker = new worker.ThreadWorker('../workers/worker.ets');\n\n// 场景3： Worker线程文件所在路径：\"{moduleName}/src/main/ets/MainAbility/ThreadFile/workers/worker.ets\"\nconst workerFA3: worker.ThreadWorker = new worker.ThreadWorker('ThreadFile/workers/worker.ets');</pre>
    <div class=\"section\" id=\"生命周期注意事项\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a><a
            name=\"%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a>     <h4>
        [h2]生命周期注意事项</h4>
        <ul>
            <li><p>Worker的创建和销毁会消耗较多的系统资源，建议开发者合理管理已创建的Worker并重复使用。Worker空闲时仍会占用资源，因此当不需要Worker时，可以调用<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-worker#terminate9\"
                    target=\"_blank\">terminate()</a>接口或<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-worker#close9\"
                    target=\"_blank\">close()</a>方法主动销毁Worker。若Worker处于已销毁或正在销毁等非运行状态时，调用其功能接口，会抛出相应的错误。
            </p></li>
            <li><p>
                Worker的数量由内存管理策略决定，设定的内存阈值为1.5GB和设备物理内存的60%中的较小者。在内存允许的情况下，系统最多可以同时运行64个Worker。如果尝试创建的Worker数量超出这一上限，系统将抛出错误：“Worker
                initialization failure, the number of workers exceeds the
                maximum.”。实际运行的Worker数量会根据当前内存使用情况实时调整。当所有Worker和主线程的累积内存占用超过设定的阈值时，系统将触发内存溢出（OOM）错误，导致应用程序崩溃。</p>
            </li>
        </ul>
    </div>
    <div class=\"section\" id=\"onallerrors接口与onerror接口之间的行为差异\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__onallerrors%E6%8E%A5%E5%8F%A3%E4%B8%8Eonerror%E6%8E%A5%E5%8F%A3%E4%B9%8B%E9%97%B4%E7%9A%84%E8%A1%8C%E4%B8%BA%E5%B7%AE%E5%BC%82\"></a><a
            name=\"onallerrors%E6%8E%A5%E5%8F%A3%E4%B8%8Eonerror%E6%8E%A5%E5%8F%A3%E4%B9%8B%E9%97%B4%E7%9A%84%E8%A1%8C%E4%B8%BA%E5%B7%AE%E5%BC%82\"></a>
        <h4>[h2]onAllErrors接口与onerror接口之间的行为差异</h4>
        <ol>
            <li><p>异常捕获范围</p>
                <p>onAllErrors接口可以捕获Worker线程的onmessage回调、timer回调以及文件执行等流程产生的全局异常。</p>
                <p>
                    onerror接口仅能捕获Worker线程的onmessage回调中同步方法产生的异常，无法捕获多线程回调和模块化相关异常。</p>
            </li>
            <li><p>异常捕获后的线程状态</p>
                <p>
                    onAllErrors接口捕获异常后，Worker线程仍然存活并可以继续使用。这使得开发者可以在捕获异常后继续执行其他操作，而不必担心线程被终止。</p>
                <p>
                    onerror接口一旦捕获到异常，Worker线程会进入销毁流程，无法继续使用。这意味着在onerror触发后，Worker线程将被终止，后续操作将无法进行。</p>
            </li>
            <li><p>适用场景</p>
                <p>
                    onAllErrors接口适用于捕获Worker线程中所有类型异常的场景，特别是确保异常发生后Worker线程仍能继续运行的复杂场景。</p>
                <p>
                    onerror接口适用于只需要捕获onmessage回调中同步异常的简单场景。由于捕获异常后线程会被销毁，适用于不需要继续使用Worker线程的情况。</p>
                <p>推荐使用onAllErrors接口，因为它提供了更全面的异常捕获能力，并且不会导致线程终止。</p></li>
        </ol>
    </div>
    <div class=\"section\" id=\"worker基本用法示例\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__worker%E5%9F%BA%E6%9C%AC%E7%94%A8%E6%B3%95%E7%A4%BA%E4%BE%8B\"></a><a
            name=\"worker%E5%9F%BA%E6%9C%AC%E7%94%A8%E6%B3%95%E7%A4%BA%E4%BE%8B\"></a>     <h4>Worker基本用法示例</h4>
        <ol>
            <li><p>DevEco Studio支持一键生成Worker，在对应的{moduleName}目录下任意位置，单击鼠标右键 &gt; New &gt;
                Worker，即可自动生成Worker的模板文件及配置信息。本文以创建“worker”为例。</p>
                <p>此外，支持手动创建Worker文件，具体方式和注意事项请参阅<a
                        href=\"#创建worker的注意事项\">创建Worker的注意事项</a>。</p></li>
            <li><p>导入Worker模块。</p>
                <pre class=\"ts\">// Index.ets\nimport { ErrorEvent, MessageEvents, worker } from '@kit.ArkTS'</pre>
            </li>
            <li><p>在宿主线程中通过调用ThreadWorker的<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-worker#constructor9\"
                    target=\"_blank\">constructor()</a>方法创建Worker对象，并注册回调函数。</p>
                <pre class=\"ts\">// Index.ets\n@Entry\n@Component\nstruct Index {\n  @State message: string = 'Hello World';\n\n  build() {\n    RelativeContainer() {\n      Text(this.message)\n        .id('HelloWorld')\n        .fontSize(50)\n        .fontWeight(FontWeight.Bold)\n        .alignRules({\n          center: { anchor: '__container__', align: VerticalAlign.Center },\n          middle: { anchor: '__container__', align: HorizontalAlign.Center }\n        })\n        .onClick(() =&gt; {\n          // 创建Worker对象\n          let workerInstance = new worker.ThreadWorker('entry/ets/workers/worker.ets');\n\n          // 注册onmessage回调，当宿主线程接收到来自其创建的Worker通过workerPort.postMessage接口发送的消息时被调用，在宿主线程执行\n          workerInstance.onmessage = (e: MessageEvents) =&gt; {\n            let data: string = e.data;\n            console.info('workerInstance onmessage is: ', data);\n          }\n\n          // 注册onAllErrors回调，可以捕获Worker线程的onmessage回调、timer回调以及文件执行等流程产生的全局异常，在宿主线程执行\n          workerInstance.onAllErrors = (err: ErrorEvent) =&gt; {\n            console.error('workerInstance onAllErrors message is: ' + err.message);\n          }\n\n          // 注册onmessageerror回调，当Worker对象接收到无法序列化的消息时被调用，在宿主线程执行\n          workerInstance.onmessageerror = () =&gt; {\n            console.error('workerInstance onmessageerror');\n          }\n\n          // 注册onexit回调，当Worker销毁时被调用，在宿主线程执行\n          workerInstance.onexit = (e: number) =&gt; {\n            // 如果Worker正常退出，code为0；如果异常退出，code为1\n            console.info('workerInstance onexit code is: ', e);\n          }\n\n          // 发送消息给Worker线程\n          workerInstance.postMessage('1');\n        })\n    }\n    .height('100%')\n    .width('100%')\n  }\n}</pre>
            </li>
            <li><p>在Worker文件中注册回调函数。</p>
                <pre class=\"ts\">// worker.ets\nimport { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';\n\nconst workerPort: ThreadWorkerGlobalScope = worker.workerPort;\n\n// 注册onmessage回调，当Worker线程收到来自其宿主线程通过postMessage接口发送的消息时被调用，在Worker线程执行\nworkerPort.onmessage = (e: MessageEvents) =&gt; {\n  let data: string = e.data;\n  console.info('workerPort onmessage is: ', data);\n\n  // 向主线程发送消息\n  workerPort.postMessage('2');\n}\n\n// 注册onmessageerror回调，当Worker对象接收到一条无法被序列化的消息时被调用，在Worker线程执行\nworkerPort.onmessageerror = () =&gt; {\n  console.error('workerPort onmessageerror');\n}\n\n// 注册onerror回调，当Worker在执行过程中发生异常被调用，在Worker线程执行\nworkerPort.onerror = (err: ErrorEvent) =&gt; {\n  console.error('workerPort onerror err is: ', err.message);\n}</pre>
            </li>
        </ol>
    </div>
    <div class=\"section\" id=\"跨har包加载worker\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__%E8%B7%A8har%E5%8C%85%E5%8A%A0%E8%BD%BDworker\"></a><a
            name=\"%E8%B7%A8har%E5%8C%85%E5%8A%A0%E8%BD%BDworker\"></a>     <h4>跨har包加载Worker</h4>
        <ol>
            <li><p>创建har详情参考<a href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/har-package\">开发静态共享包</a>。
            </p></li>
            <li><p>在har中创建Worker线程文件相关内容。</p>
                <pre class=\"ts\">// worker.ets\nworkerPort.onmessage = (e: MessageEvents) =&gt; {\n  console.info('worker thread receive message: ', e.data);\n  workerPort.postMessage('worker thread post message to main thread');\n}</pre>
            </li>
            <li><p>在entry模块的oh-package.json5文件中配置har包的依赖。</p>
                <pre class=\"ts\">// 在entry模块配置har包的依赖\n{\n  \"name\": \"entry\",\n  \"version\": \"1.0.0\",\n  \"description\": \"Please describe the basic information.\",\n  \"main\": \"\",\n  \"author\": \"\",\n  \"license\": \"\",\n  \"dependencies\": {\n    \"har\": \"file:../har\"\n  }\n}</pre>
            </li>
            <li><p>在entry模块中加载har包中的Worker线程文件。</p>
                <pre class=\"ts\">// Index.ets\nimport { worker } from '@kit.ArkTS';\n\n@Entry\n@Component\nstruct Index {\n  @State message: string = 'Hello World';\n\n  build() {\n    RelativeContainer() {\n      Text(this.message)\n        .id('HelloWorld')\n        .fontSize(50)\n        .fontWeight(FontWeight.Bold)\n        .alignRules({\n          center: { anchor: '__container__', align: VerticalAlign.Center },\n          middle: { anchor: '__container__', align: HorizontalAlign.Center }\n        })\n        .onClick(() =&gt; {\n          // 通过@标识路径加载形式，加载har中Worker线程文件\n          let workerInstance = new worker.ThreadWorker('@har/ets/workers/worker.ets');\n          workerInstance.onmessage = () =&gt; {\n            console.info('main thread onmessage');\n          };\n          workerInstance.postMessage('hello world');\n        })\n    }\n    .height('100%')\n    .width('100%')\n  }\n}</pre>
            </li>
        </ol>
    </div>
    <div class=\"section\" id=\"多级worker生命周期管理\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__%E5%A4%9A%E7%BA%A7worker%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E7%AE%A1%E7%90%86\"></a><a
            name=\"%E5%A4%9A%E7%BA%A7worker%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F%E7%AE%A1%E7%90%86\"></a>     <h4>
        多级Worker生命周期管理</h4>
        <p>
            支持创建多级Worker，即父Worker可以创建子Worker，形成层级线程关系。由于Worker线程的生命周期由开发者自行管理，因此需要正确管理多级Worker的生命周期。如果销毁父Worker时未能终止其子Worker的运行，可能会导致不可预期的结果。因此需确保子Worker的生命周期在父Worker生命周期范围内，销毁父Worker前，先销毁所有子Worker。</p>
    </div>
    <div class=\"section\" id=\"推荐使用示例\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__%E6%8E%A8%E8%8D%90%E4%BD%BF%E7%94%A8%E7%A4%BA%E4%BE%8B\"></a><a
            name=\"%E6%8E%A8%E8%8D%90%E4%BD%BF%E7%94%A8%E7%A4%BA%E4%BE%8B\"></a>     <h4>[h2]推荐使用示例</h4>
        <pre class=\"ts\">// 在主线程中创建Worker线程（父Worker），在worker线程中再次创建Worker线程（子Worker）\n// main thread\nimport { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS';\n\n// 主线程中创建父worker对象\nconst parentworker = new worker.ThreadWorker('entry/ets/workers/parentworker.ets');\n\nparentworker.onmessage = (e: MessageEvents) =&gt; {\n  console.info('主线程收到父worker线程信息 ' + e.data);\n}\n\nparentworker.onexit = () =&gt; {\n  console.info('父worker退出');\n}\n\nparentworker.onAllErrors = (err: ErrorEvent) =&gt; {\n  console.error('主线程接收到父worker报错 ' + err);\n}\n\nparentworker.postMessage('主线程发送消息给父worker-推荐示例');</pre>
        <pre class=\"ts\">// parentworker.ets\nimport { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';\n\n// 创建父Worker线程中与主线程通信的对象\nconst workerPort: ThreadWorkerGlobalScope = worker.workerPort;\n\nworkerPort.onmessage = (e : MessageEvents) =&gt; {\n  if (e.data == '主线程发送消息给父worker-推荐示例') {\n    let childworker = new worker.ThreadWorker('entry/ets/workers/childworker.ets');\n\n    childworker.onmessage = (e: MessageEvents) =&gt; {\n      console.info('父Worker收到子Worker的信息 ' + e.data);\n      if (e.data == '子Worker向父Worker发送信息') {\n        workerPort.postMessage('父Worker向主线程发送信息');\n      }\n    }\n\n    childworker.onexit = () =&gt; {\n      console.info('子Worker退出');\n      // 子Worker退出后再销毁父Worker\n      workerPort.close();\n    }\n\n    childworker.onAllErrors = (err: ErrorEvent) =&gt; {\n      console.error('子Worker发生报错 ' + err);\n    }\n\n    childworker.postMessage('父Worker向子Worker发送信息-推荐示例');\n  }\n}</pre>
        <pre class=\"ts\">// childworker.ets\nimport { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';\n\n// 创建子Worker线程中与父Worker线程通信的对象\nconst workerPort: ThreadWorkerGlobalScope = worker.workerPort;\n\nworkerPort.onmessage = (e: MessageEvents) =&gt; {\n  if (e.data == '父Worker向子Worker发送信息-推荐示例') {\n    // 子Worker线程业务逻辑...\n    console.info('业务执行结束，然后子Worker销毁');\n    workerPort.close();\n  }\n}</pre>
    </div>
    <div class=\"section\" id=\"不推荐使用示例\"><a
            name=\"ZH-CN_TOPIC_0000002278863044__%E4%B8%8D%E6%8E%A8%E8%8D%90%E4%BD%BF%E7%94%A8%E7%A4%BA%E4%BE%8B\"></a><a
            name=\"%E4%B8%8D%E6%8E%A8%E8%8D%90%E4%BD%BF%E7%94%A8%E7%A4%BA%E4%BE%8B\"></a>     <h4>
        [h2]不推荐使用示例</h4>
        <p>不建议在父Worker销毁后，子Worker仍向父Worker发送消息。</p>
        <pre class=\"ts\">// main thread\nimport { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS';\n\nconst parentworker = new worker.ThreadWorker('entry/ets/workers/parentworker.ets');\n\nparentworker.onmessage = (e: MessageEvents) =&gt; {\n  console.info('主线程收到父Worker信息' + e.data);\n}\n\nparentworker.onexit = () =&gt; {\n  console.info('父Worker退出');\n}\n\nparentworker.onAllErrors = (err: ErrorEvent) =&gt; {\n  console.error('主线程接收到父Worker报错 ' + err);\n}\n\nparentworker.postMessage('主线程发送消息给父Worker');</pre>
        <pre class=\"ts\">// parentworker.ets\nimport { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';\n\nconst workerPort: ThreadWorkerGlobalScope = worker.workerPort;\n\nworkerPort.onmessage = (e : MessageEvents) =&gt; {\n  console.info('父Worker收到主线程的信息 ' + e.data);\n\n  let childworker = new worker.ThreadWorker('entry/ets/workers/childworker.ets')\n\n  childworker.onmessage = (e: MessageEvents) =&gt; {\n    console.info('父Worker收到子Worker的信息 ' + e.data);\n  }\n\n  childworker.onexit = () =&gt; {\n    console.info('子Worker退出');\n    workerPort.postMessage('父Worker向主线程发送信息');\n  }\n\n  childworker.onAllErrors = (err: ErrorEvent) =&gt; {\n    console.error('子Worker发生报错 ' + err);\n  }\n\n  childworker.postMessage('父Worker向子Worker发送信息');\n\n  // 创建子Worker后，销毁父Worker\n  workerPort.close();\n}</pre>
        <pre class=\"ts\">// childworker.ets\nimport { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';\n\nconst workerPort: ThreadWorkerGlobalScope = worker.workerPort;\n\nworkerPort.onmessage = (e: MessageEvents) =&gt; {\n  console.info('子Worker收到信息 ' + e.data);\n\n  // 父Worker销毁后，子Worker向父Worker发送信息，行为不可预期\n  workerPort.postMessage('子Worker向父Worker发送信息');\n  setTimeout(() =&gt; {\n    workerPort.postMessage('子Worker向父Worker发送信息');\n  }, 1000);\n}</pre>
        <p>
            不建议在父Worker发起销毁操作的执行阶段创建子Worker。在创建子Worker线程之前，需确保父Worker线程始终处于存活状态，不建议在不确定父Worker是否发起销毁操作的情况下创建子Worker。</p>
        <pre class=\"ts\">// main thread\nimport { worker, MessageEvents, ErrorEvent } from '@kit.ArkTS';\n\nconst parentworker = new worker.ThreadWorker('entry/ets/workers/parentworker.ets');\n\nparentworker.onmessage = (e: MessageEvents) =&gt; {\n  console.info('主线程收到父Worker信息' + e.data);\n}\n\nparentworker.onexit = () =&gt; {\n  console.info('父Worker退出');\n}\n\nparentworker.onAllErrors = (err: ErrorEvent) =&gt; {\n  console.error('主线程接收到父Worker报错 ' + err);\n}\n\nparentworker.postMessage('主线程发送消息给父Worker');</pre>
        <pre class=\"ts\">// parentworker.ets\nimport { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';\n\nconst workerPort: ThreadWorkerGlobalScope = worker.workerPort;\n\nworkerPort.onmessage = (e : MessageEvents) =&gt; {\n  console.info('父Worker收到主线程的信息 ' + e.data);\n\n  // 父Worker销毁后创建子Worker，行为不可预期\n  workerPort.close();\n  let childworker = new worker.ThreadWorker('entry/ets/workers/childworker.ets');\n\n  // 子Worker线程未确认创建成功前销毁父Worker，行为不可预期\n  // let childworker = new worker.ThreadWorker('entry/ets/workers/childworker.ets');\n  // workerPort.close();\n\n  childworker.onmessage = (e: MessageEvents) =&gt; {\n    console.info('父Worker收到子Worker的信息 ' + e.data);\n  }\n\n  childworker.onexit = () =&gt; {\n    console.info('子Worker退出');\n    workerPort.postMessage('父Worker向主线程发送信息');\n  }\n\n  childworker.onAllErrors = (err: ErrorEvent) =&gt; {\n    console.error('子Worker发生报错 ' + err);\n  }\n\n  childworker.postMessage('父Worker向子Worker发送信息');\n}</pre>
        <pre class=\"ts\">// childworker.ets\nimport { ErrorEvent, MessageEvents, ThreadWorkerGlobalScope, worker } from '@kit.ArkTS';\n\nconst workerPort: ThreadWorkerGlobalScope = worker.workerPort;\n\nworkerPort.onmessage = (e: MessageEvents) =&gt; {\n  console.info('子Worker收到信息 ' + e.data);\n}</pre>
    </div>
</div>
<div></div>
</body>
</html>"